private void buttonOK_Click(object sender, RoutedEventArgs e)
{
    this.DialogResult = true;
}

private void buttonCancel_Click(object sender, RoutedEventArgs e)
{
    this.DialogResult = false;
}

                        

                                using Pixoneer.NXDL;             // 기본 함수 관련 기능
using Pixoneer.NXDL.NXPlanet;    // 구 기반 도시 관련 기능
using Pixoneer.NXDL.NNCW;        // NCW 환경 관련 기능
using Pixoneer.NXDL.NEQUIP;      // NCW 환겨에서 시뮬레이션하는 모델 관련 기능

namespace XDL_PlanetView4
{
    public partial class MainWindow : Window
    {
        private XncwTheater xncwTheater;       // ncw 환경을 위한 레이어
        private XncwObserver xncwObserver2D;   // 2D Planet에서 시뮬레이션 모델 주시 기능을 담당할 레이어
        private XncwObserver xncwObserver3D;   // 3D Planet에서 시뮬레이션 모델 주시 기능을 담당할 레이어

        public MainWindow()
        {
            InitializeComponent();

            // PlanetView 2D/3D의 배경색 설정
            nxPlanetView2D.BackColor = System.Drawing.Color.Black;
            nxPlanetView3D.BackColor = System.Drawing.Color.Black;

            // NCW를 위한 theater 객체, observer 객체 생성
            xncwTheater = new XncwTheater();
            xncwObserver2D = new XncwObserver();
            xncwObserver3D = new XncwObserver();
        }
    }
}

                        

                                private void Window_Loaded(object sender, RoutedEventArgs e)
{
    nxPlanetView2D.AddRenderLayer(ref nxPlanetLayer2D);

    // Theater 객체를 Planet 2D/3D 뷰에 추가
    xncwTheater.AttachTo(nxPlanetView2D);
    xncwTheater.AttachTo(nxPlanetView3D);

    // Theater의 모든 객체를 PlanetView 3D에서는 항상 주시할 수 있도록 설정
    xncwTheater.ShowAllObjects(nxPlanetView3D, true);

    // 각 PlanetView에 관찰을 위한 Observer 객체를 각각 추가한다.
    xncwObserver2D.AttachTo(nxPlanetView2D);
    xncwObserver3D.AttachTo(nxPlanetView3D);

    XGeoPoint gpEye = XGeoPoint.FromDegree(127.4, 38.0, 1500000);
    // Planet2D 모드의 camera 위치 설정
    nxPlanetView2D.SetCameraPosition(gpEye, XAngle.FromDegree(0.0));
    // Planet3D 모드의 camera 위치 설정
    nxPlanetView3D.SetCameraPosition(gpEye, XAngle.FromDegree(0.0), XAngle.FromDegree(-90.0), XAngle.FromDegree(0.0));
}

private void Window_Closed(object sender, EventArgs e)
{
    Xfn.Close();
}

                        

                                using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.IO;          // FileStream 관련 기능
using System.Threading;   // Threading 관련 기능

using Pixoneer.NXDL;          // 기본 함수 관련 기능
using Pixoneer.NXDL.NNCW;     // NCW 환경 관련 기능
using Pixoneer.NXDL.NEQUIP;   // NCW 환경에서 시뮬레이션하는 모델 관련 기능

namespace XDL_PlanetView4
{
    class MyPlane : XAircraft
    {
        public string modelPathData;  // 시뮬레이션 데이터 파일 경로
        public string modelPathModel; // 모델 파일 경로
        public string modelName;      // 모델 이름
        public int modelID;           // 모델 구별자

        // 시뮬레이션 주시(관측) 모드
        public XncwObserver.eViewMode cameraMode;
        // 모델의 경계 영역 도시 여부
        public bool modelShowBoundingBox;

        private FileStream modelFileData;      // 시뮬레이션 데이터파일
        private Thread modelThread;            // 시뮬레이션을 위한 쓰레드
        private bool runThread;                // 시뮬레이션 쓰레드 여부 결정
        //internal bool Scalable;

        // 클래스 생성자
        public MyPlane()
        {
            modelPathData = "";
            modelPathModel = "";
            modelName = "MyPlane";
            modelID = 0;

            // Camera 관측모드
            // Unuable인 경우 특정 모델을 주시하지 않을 때 사용
            cameraMode = XncwObserver.eViewMode.Unusable;
            modelShowBoundingBox = false;
            modelFileData = null;
            modelThread = null;
            runThread = false;
        }

        // 모델 경로, 시뮬레이션 데이터 경로, 이름 및 ID를 입력으로 받아 초기화하는 함수
        public bool Initialize(string pathModel, string pathData, string name, int nID)
        {
            // 파일 경로로부터 모델 데이터 로딩
            if (!LoadModel(pathModel)) return false;

            // 멤버 변수 설정
            modelName = name;
            modelID = nID;
            modelPathData = pathData;

            // 시뮬레이션 데이터 로딩
            modelFileData = new FileStream(modelPathData, FileMode.Open, FileAccess.Read);
            return true;
        }

        // 시뮬레이션 기능 및 데이터를 해제하는 함수
        public void Uninitialize()
        {

            // 쓰레드가 있는 경우 이를 해제
            if (modelThread != null)
            {
                runThread = false;
                if (modelThread.IsAlive)
                    modelThread.Join();
                modelThread = null;

            }
            // 시뮬레이션 데이터가 있는 경우 이를 해제
            if (modelFileData != null) modelFileData.Close();
        }

        // 시뮬레이션 함수
        public void SimulationThread()
        {
            // 시뮬레이션 데이터가 없는 경우 진행하지 않는다.
            if (modelFileData == null) return;

            // 시뮬레이션 실행 여부를 실행하는 것으로 설정
            runThread = true;
            // 시뮬레이션 단위 데이터 크기 설정
            int frameDataSize = 14/* 시뮬레이션 단위를 이루는 항목 개수 */ * 4 /*float 데이터 크기 */;
            // 전체 파일 크기를 시뮬레이션 단위 데이터 크기로 나누어 전체 시뮬레이션 단위 개수 계산
            long dataSize = modelFileData.Length / frameDataSize;
            // 시뮬레이션 단위를 읽기 위한 buffer 생성
            byte[] buff = new byte[frameDataSize];

            while (runThread)
            {
                int idx = 0, count = 0;
                // 시뮬레이션 데이터 파일의 처음으로 이동
                modelFileData.Seek(0, SeekOrigin.Begin);

                do
                {
                    if (!runThread) break;

                    // 시뮬레이션 데이터 파일에서 시뮬레이션 단위 데이터 읽기
                    count = modelFileData.Read(buff, 0, frameDataSize);

                    // 시뮬레이션 단위 데이터에서 속도 가져오기
                    double speed = BitConverter.ToSingle(buff, 0);
                    // 시뮬레이션 단위 데이터에서 위치의 위도 가져오기
                    double lat = BitConverter.ToSingle(buff, 4);
                    // 시뮬레이션 단위 데이터에서 위치의 경도 가져오기
                    double lon = BitConverter.ToSingle(buff, 8);
                    // 시뮬레이션 단위 데이터에서 위치의 높이 가져오기
                    double alt = BitConverter.ToSingle(buff, 12);

                    // 시뮬레이션 단위 데이터에서 자세의 yaw 가져오기
                    double yaw = BitConverter.ToSingle(buff, 16);
                    // 시뮬레이션 단위 데이터에서 자세의 roll 가져오기
                    double roll = BitConverter.ToSingle(buff, 20);
                    // 시뮬레이션 단위 데이터에서 자세의 pitch 가져오기
                    double pitch = BitConverter.ToSingle(buff, 24);

                    XGeoPoint geoPos = new XGeoPoint();
                    geoPos.lond = lon;
                    geoPos.latd = lat;
                    geoPos.hgt = alt;

                    // 모델의 위치 설정
                    SetPosition(geoPos);
                    // 모델의 자세 설정
                    SetYawPitchRoll(XAngle.FromDegree(yaw), XAngle.FromDegree(pitch), XAngle.FromDegree(roll));
                    // 100 milli second 동안 시뮬레이션을 쉰다.
                    Thread.Sleep(100);

                    idx++;
                }
                // Thread 종료 조건을 검사함
                while ((count == frameDataSize) && (idx < dataSize));
                Thread.Sleep(100);
            }
        }

        // 시뮬레이션을 시작하는 함수
        public void Start()
        {
            // 이미 thread가 실행된 상태이면 리턴
            if (modelThread != null) return;

            // SimulationThread 함수를 이용한 thread 생성
            modelThread = new Thread(SimulationThread);
            // Thread 시작
            modelThread.Start();
        }
    }
}

                        

                                // AddPlane.xaml.cs

namespace XDL_PlanetView4
{
    public partial class AddPlane : Window
    {
        public string pathModel;  // 모델 경로
        public string pathData;   // 시뮬레이션 데이터 경고
        public string nameModel;  // 모델 이름
        public int ID;            // 모델 식별자

        // AddPlane 생성자
        public AddPlane()
        {
            InitializeComponent();
        }

        // OK 버튼 이벤트함수
        private void buttonOK_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = true;
            ID = int.Parse(textBoxID.Text);
            nameModel = textBoxName.Text;
        }

        private void buttonCancel_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = false;
        }

         // 3DS 모델 파일 경로를 설정하는 buttonLoadModel 버튼 이벤트 함수
        private void buttonLoadModel_Click(object sender, RoutedEventArgs e)
        {
            // 열기 대화 상자 생성
            OpenFileDialog dlg = new OpenFileDialog();
            // 3DS 모델 파일을 선택할 수 있도록 열기 대화상자 필터 설정
            dlg.Filter = "Model FIle(*.3ds)|*.3ds;||";
            Nullable<bool> result = dlg.ShowDialog();
            if (result != true) return;

            // 모델 경로 설정
            pathModel = dlg.FileName;
            textBoxPathModel.Text = pathModel;
        }

        // 시뮬레이션 데이터 경로를 설정하는 buttonLoadData 버튼 이벤트 함수
        private void buttonLoadData_Click(object sender, RoutedEventArgs e)
        {
            // 열기 대화 상자 생성
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Filter = "Data File(*.dat)|*.dat;||";
            Nullable<bool> result = dlg.ShowDialog();
            if (result != true) return;

            // 시뮬레이션 경로 설정
            pathData = dlg.FileName;
            textBoxPathData.Text = pathData;
        }
    }
}

                        

                                // NCW 모델을 관리하기 위한 List 객체
private List<MyPlane> modelList = new List<MyPlane>();

                        

                                // 화면 갱신을 위한 Thread 
private Thread threadRefresh = null;
private bool runThread = false;

// 화면 갱신을 요청하는 thread를 위한 함수
public void RefreshScreenThread()
{
    // thread 실행 여부 설정
    runThread = true;
    while (runThread)
    {
        // xnwTheater의 가시영역 갱신
        xncwTheater.UpdateVisibleArea();

        // nxPlanetView2D와 nxPlanetView3D에 화면 갱신 요청
        nxPlanetView2D.RefreshScreen();
        nxPlanetView3D.RefreshScreen();

        // 100 mili second 동안 threading을 쉰다.
        Thread.Sleep(100);
    }
}

                        

                                private void addModelMenuItem_Click(object sender, RoutedEventArgs e)
{
    // AddPlane 생성하여 MyPlane을 위한 속성 설정
    AddPlane addForm = new AddPlane();

    Nullable<bool> result = addForm.ShowDialog();
    if (result != true) return;

    MyPlane newPlane = new MyPlane();
    // MyPlane 객체에 매개변수를 이용하여 초기화
    if (!newPlane.Initialize(addForm.pathModel, addForm.pathData, addForm.nameModel, addForm.ID))
    {
        MessageBox.Show("Model을 로딩할 수 없습니다.");
        return;
    }

    // MyPlane 객체의 크기조절 여부를 조절한다.
    newPlane.Scalable = false;

    XEquipObj newObj = newPlane;
    // xncwTheater에 새로운 모델을 추가한다.
    if (xncwTheater.AddEquipment(newPlane.modelID, ref newObj))
    {
        // 모델 리스트에 새로운 모델 추가
        modelList.Add(newPlane);

        // 새로운 모델의 시뮬레이션 시작
        newPlane.Start();
        // xncwTheater의 가시영역 갱신
        xncwTheater.UpdateVisibleArea();

        // nxPlanetView2D와 nxPlanetView3D의 도시 갱신 요청
        nxPlanetView2D.RefreshScreen();
        nxPlanetView3D.RefreshScreen();

        if (threadRefresh == null)
        {
            // 화면 갱신을 위한 thread 생성
            threadRefresh = new Thread(RefreshScreenThread);
            threadRefresh.Start();
        }
    }
    else
        // xncwTheater에 모델 추가를 하지 못하면 MyPlane을 해제한다.
        newPlane.Uninitialize();
}

                        

                                private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
    // 화면 갱신을 위한 thread를 해제한다.
    if (threadRefresh != null)
    {
        runThread = false;
        if (threadRefresh.IsAlive)
            threadRefresh.Join();
        threadRefresh = null;
    }

    // MyPlane 객체를 해제한다.
    foreach (MyPlane obj in modelList)
    {
        obj.Uninitialize();
    }
    modelList.Clear();
}

                        

                                private NXPlanetLayer nxPlanetLayer2D;

public MainWindow()
{
    ...

    // 윈도우 이벤트를 받기 위한 NXPlanetLayer 변수 및 이벤트 함수 추가
    nxPlanetLayer2D = new NXPlanetLayer();
    nxPlanetLayer2D.OnWndProc += new NXPlanetLayerWndProcEvent(nxPlanetLayer2D_OnWndProc);

    // xncwTheater의 OnPicked 이벤트 함수 추가
    xncwTheater.OnPicked += new XncwTheaterPickEvent(xncwTheater_OnPicked);
}

private bool nxPlanetLayer2D_OnWndProc(object sender, NXPlanetDrawArgs e, ref System.Windows.Forms.Message m)
{
    // 마우스 왼쪽 버튼을 더블 클릭
    if (m.Msg == Pixoneer.NXDL.XWndMsg.XWM_LBUTTONDBLCLK)
    {
        // 화면 좌표
        XVertex2d scrPos = new XVertex2d();
        scrPos.x = Pixoneer.NXDL.XWndMsg.GetLowValue(m.LParam);
        scrPos.y = Pixoneer.NXDL.XWndMsg.GetHighValue(m.LParam);

        // xncwTheater에 화면 좌표에 대해 nxPlanetView2D에서 hit-test를 수행한다.
        // Pick 함수가 성공적으로 실행되면 xncwTheater의 OnPicked가 호출된다.
        xncwTheater.Pick(nxPlanetView2D.GetHandle(), scrPos);
    }
    return default(bool);
}


                        

                                using Pixoneer.NXDL.NNCW;

namespace XDL_PlanetView4
{
    public partial class PlaneProperty : Window
    {
        public string modelName;    // 모델 이름
        public int modelID;

        public double modelScaleX, modelScaleY, modelScaleZ;    // 모델 크기 조절 요소
        public bool modelScalable;                              // 모델 크기 조절 여부
        public XncwObserver.eViewMode cameraMode;               // 카메라 모드
        public bool modelShowBoundingBox;                       // 모델 경계 영역 도시 여부

        public PlaneProperty()
        {
            InitializeComponent();

            modelName = "";
            modelID = 0;
            modelScaleX = modelScaleY = modelScaleZ = 2.0;
            modelScalable = false;
            cameraMode = XncwObserver.eViewMode.Unusable;
            modelShowBoundingBox = false;
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            textBoxID.Text = modelID.ToString();
            textBoxName.Text = modelName;

            textBoxScaleX.Text = modelScaleX.ToString();
            textBoxScaleY.Text = modelScaleY.ToString();
            textBoxScaleZ.Text = modelScaleZ.ToString();

            checkBoxScalable.IsChecked = modelScalable;
            checkBoxShowBoundingBox.IsChecked = modelShowBoundingBox;

            int idx = (int)cameraMode;

            // Camera mode가 유효한 값이 아닌 경우, Camera mode를 위한 combo box의 마지막 아이템인 Unusable로 설정
            if (idx < 0 || idx >= comboBoxCameraMode.Items.Count)
                idx = comboBoxCameraMode.Items.Count - 1;

            comboBoxCameraMode.SelectedIndex = idx;
        }

        private void buttonOK_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = true;
            int idx = comboBoxCameraMode.SelectedIndex;

            // Camera mode가 유효하지 않는 경우에는 Inusable으로 설정
            if (idx > (int)XncwObserver.eViewMode.Far2Obj)
                idx = (int)XncwObserver.eViewMode.Unusable;

            cameraMode = (XncwObserver.eViewMode)idx;
            modelName = textBoxName.Text;

            // 모델 크기 조절. ModelScalable이 true인 경우 적용된다.
            modelScaleX = double.Parse(textBoxScaleX.Text);
            modelScaleY = double.Parse(textBoxScaleY.Text);
            modelScaleZ = double.Parse(textBoxScaleZ.Text);

            Nullable<bool> result = checkBoxScalable.IsChecked;
            if (result != true)
            {
                modelScalable = false;
            }
            else
            {
                modelScalable = true;
            }

            Nullable<bool> result1 = checkBoxShowBoundingBox.IsChecked;
            if (result1 != true)
            {
                modelShowBoundingBox = false;
            }
            else
            {
                modelShowBoundingBox = true;
            }
        }

        private void buttonCancel_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = false;
        }
    }
}

                        

                                bool xncwTheater_OnPicked(object sender, NXPlanetDrawArgs e, long ID)
{
    // ID에 대응되는 장비를 xncwTheater에서 가져온다.
    XEquipObj obj = xncwTheater.GetEquipment(ID);
    // ID에 대응되는 객체가 없는 경우 null 객체를 반환한다.
    if (obj == null) return false;

    MyPlane modelPlane = (MyPlane)obj;

    //MyPlane 객체의 속성으로 PlaneProperty 값을 설정한다.
    Action action = () =>
    {
        PlaneProperty property = new PlaneProperty();

        property.modelID = (int)ID;
        property.modelName = modelPlane.modelName;
        property.modelScalable = modelPlane.Scalable;
        property.modelScaleX = modelPlane.Scale.x;
        property.modelScaleY = modelPlane.Scale.y;
        property.modelScaleZ = modelPlane.Scale.z;
        property.modelShowBoundingBox = modelPlane.modelShowBoundingBox;
        property.cameraMode = modelPlane.cameraMode;

        Nullable<bool> result = property.ShowDialog();
        if (result != true)
        {
            return;// false;
    }

        // PlaneProperty xaml을 이용해 설정한 값을 MyPlane에 설정한다.
        modelPlane.Scalable = property.modelScalable;
        modelPlane.Scale = new XVertex3d(property.modelScaleX, property.modelScaleY, property.modelScaleZ);

        modelPlane.ShowBoundingBox(property.modelShowBoundingBox);
        modelPlane.cameraMode = property.cameraMode;

        // CameraMode를 Unusable로 설정한 경우,
        // 특정 객체를 주시하는 것이 아니라 모든 객체를 확인할 수 있도록 xncwObserver2D, xncwObserver3D의 SurveyNone() 함수로 설정
        if (modelPlane.cameraMode == XncwObserver.eViewMode.Unusable)
        {
            xncwObserver2D.SurveyNone();
            xncwObserver3D.SurveyNone();
        }
        else
        {
        // xncwObserver2D에서 선택한 객체와 camera mode로 대상 객체를 주시하도록 설정
        xncwObserver2D.SurveyTargetObj(obj, modelPlane.cameraMode);
        // 객체 주시를 위한 거리를 설정
        xncwObserver2D.SetDistance(4000);
        // xncwObserver3D에서 선택한 객체와 camera mode로 대상 객체를 주시하도록 설정
        xncwObserver3D.SurveyTargetObj(obj, modelPlane.cameraMode);
            xncwObserver3D.SetDistance(4000);
        }

        // xncwTheater의 가시 영역을 갱신한다.
        xncwTheater.UpdateVisibleArea();

        // nxPlanetView2D와 nxPlanetView3D에 화면 갱신을 요청한다.
        nxPlanetView2D.RefreshScreen();
        nxPlanetView3D.RefreshScreen();
    };
    Dispatcher.BeginInvoke(action);
    return default(bool);
}